home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Tools / dbmunbuild / dbmunbuild.c next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  6.6 KB  |  372 lines

  1. /* dbmunbuild.c: dump database into files. */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Tools/dbmunbuild/RCS/dbmunbuild.c,v 6.0 1991/12/18 20:30:06 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Tools/dbmunbuild/RCS/dbmunbuild.c,v 6.0 1991/12/18 20:30:06 jpo Rel $
  9.  *
  10.  * $Log: dbmunbuild.c,v $
  11.  * Revision 6.0  1991/12/18  20:30:06  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16. #include "util.h"
  17. #include "table.h" 
  18. #include "dbase.h"
  19. #include "sys.file.h"
  20. #include <ctype.h>
  21. #include <varargs.h>
  22.  
  23. extern char *ppdbm;
  24. extern char *dupfpath();
  25. extern char *multcat();
  26.  
  27. extern Table **tb_all;
  28.  
  29. #ifdef GDBM
  30. GDBM_FILE    thedb;
  31. #define store(x,y)    gdbm_store (thedb, x, y, GDBM_REPLACE)
  32. #define fetch(x)    gdbm_fetch (thedb, x)
  33. #define firstkey()    gdbm_firstkey(thedb)
  34. #define nextkey(x)    gdbm_nextkey(thedb, (x))
  35. #else
  36. #ifndef GCC_DBM_OK
  37. #if sparc && defined(__GNUC__)    /* work around bug in gcc 1.37 sparc version */
  38.  #error GCC and dbm do not get along on a sparc - compile with cc.
  39. #endif
  40. #endif
  41. #endif
  42.  
  43. #ifdef NDBM
  44. #define        fetch(x)        dbm_fetch(thedb, (x))
  45. #define        store(x, y)     dbm_store(thedb, (x), (y), DBM_REPLACE)
  46. #define        delete(x)       dbm_delete(thedb, (x))
  47. #define firstkey()    dbm_firstkey(thedb)
  48. #define nextkey(x)    dbm_nextkey(thedb)
  49. DBM     *thedb;
  50. # endif
  51.  
  52. #define TB_FLAG_MAGIC        0x100
  53. #define TB_FLAG_NOTTHISONE    0x200
  54.  
  55. /*
  56.  * dbm expanded structure
  57.  */
  58.  
  59. #define MDB     50
  60.  
  61. static int     ndbents;
  62.  
  63. struct  db      {
  64.     char    *d_table;
  65.     char    *d_value;
  66. } dbs[MDB], *lastdb;
  67.  
  68. static int verbose;
  69. static int markedtbls;
  70. #define MARKED_IN    1
  71. #define MARKED_OUT    2
  72.  
  73. static char *myname;
  74. static char *Usage = "Usage: %s [-d database] [-t table] [-v] directory";
  75.  
  76. static void dumpdb ();
  77. static void write_records ();
  78. static void write_entry ();
  79. static void dssplit ();
  80. static void dbfinit ();
  81. static void open_table ();
  82. static void close_a_file ();
  83. static void adios (), advise ();
  84. static void mark_table ();
  85.  
  86. main(argc, argv)
  87. int argc;
  88. char **argv;
  89. {
  90.     int opt;
  91.     extern char *optarg;
  92.     extern int optind;
  93.     sys_init(myname = argv[0]);
  94.  
  95.     while ((opt = getopt (argc, argv, "d:t:T:v")) != EOF) {
  96.         switch (opt) {
  97.             case 'd':
  98.             ppdbm = optarg;
  99.             break;
  100.             case 'v':
  101.             verbose = 1;
  102.             break;
  103.             case 't':
  104.             if (markedtbls == MARKED_OUT)
  105.                 adios (NULLCP, "Can't have -T and -t");
  106.             markedtbls = MARKED_IN;
  107.             mark_table (optarg);
  108.             break;
  109.             case 'T':
  110.             if (markedtbls == MARKED_IN)
  111.                 adios (NULLCP, "Can't have -T and -t");
  112.             markedtbls = MARKED_OUT;
  113.             mark_table (optarg);
  114.             break;
  115.  
  116.             default:
  117.             adios (NULLCP, Usage, myname);
  118.         }
  119.     }
  120.     argc -= optind;
  121.     argv += optind;
  122.     if (argc != 1)
  123.         adios (NULLCP, Usage, myname);
  124.  
  125.     if(!isstr(ppdbm))
  126.         adios (NULLCP, "cannot find database path\n");
  127.     dbfinit(ppdbm);
  128.  
  129.     dumpdb (*argv);
  130.     exit (0);
  131. }
  132. static void mark_table (str)
  133. char *str;
  134. {
  135.     Table *tb;
  136.  
  137.     if ((tb = tb_nm2struct (str)) == NULL)
  138.         adios (NULLCP, "Unknown table %s", str);
  139.     tb -> tb_flags |= TB_FLAG_NOTTHISONE;
  140. }
  141.  
  142. static void dumpdb (dir)
  143. char *dir;
  144. {
  145.     datum key;
  146.     datum value;
  147.  
  148.     for (key = firstkey(); key.dptr != NULL; key = nextkey(key)) {
  149.         value = fetch(key);
  150.         if (value.dptr == NULLCP)
  151.             adios (NULLCP, "Database fetch failed");
  152.         write_records (&key, &value, dir);
  153.     }
  154.     close_tables ();
  155. }
  156.  
  157.  
  158. static void write_records (key, val, dir)
  159. datum *key, *val;
  160. char *dir;
  161. {
  162.     struct db *dp;
  163.  
  164.     dssplit (val -> dptr);
  165.     for (dp = dbs; dp < lastdb; dp++)
  166.         write_entry (key, dp, dir);
  167. }
  168.  
  169. static void write_entry (key, dp, dir)
  170. datum *key;
  171. struct db *dp;
  172. char *dir;
  173. {
  174.     Table *tb;
  175.  
  176.     if ((tb = tb_nm2struct (dp -> d_table)) == NULL) {
  177.         advise (NULLCP, "No such table %s", dp -> d_table);
  178.         return;
  179.     }
  180.     if (markedtbls == MARKED_OUT &&
  181.         (tb -> tb_flags & TB_FLAG_NOTTHISONE))
  182.         return;
  183.     if (markedtbls == MARKED_IN &&
  184.         (tb -> tb_flags & TB_FLAG_NOTTHISONE) == 0)
  185.         return;
  186.  
  187.     if (tb -> tb_fp == NULL)
  188.         open_table (tb, dir);
  189.     fprintf (tb -> tb_fp, "%s:%s\n", key -> dptr, dp -> d_value);
  190.     if (ferror (tb -> tb_fp))
  191.         adios (dp -> d_table, "Write error on table");
  192. }
  193.  
  194.  
  195. static void dssplit(str)
  196. register char   *str;
  197. {
  198.     register struct db      *dp;
  199.     static  char    ti[BUFSIZ];
  200.  
  201.     ndbents = 0;
  202.     str = strcpy(ti, str);
  203.     for(dp = dbs ; dp < &dbs[sizeof(dbs)/sizeof(dbs[0])]; dp++){
  204.         if(*str == 0)
  205.             break;
  206.         dp->d_table = str;
  207.         while(*str && *str != ' ')
  208.             str++;
  209.         *str++ = 0;
  210.         dp->d_value = str;
  211.         while(*str && *str != FS)
  212.             str++;
  213.         ndbents++;
  214.         if(*str == FS)
  215.             *str++ = 0;
  216.     }
  217.     lastdb = dbs + ndbents;
  218. }
  219.  
  220. /*
  221.  * Initialize the dbm file.
  222.  */
  223.  
  224. static void dbfinit(filename)
  225. char *filename;
  226. {
  227. #ifdef GDBM
  228.     char name[BUFSIZ];
  229.     (void) sprintf (name, "%s.gdbm", filename);
  230.     filename = name;
  231.     if ((thedb = gdbm_open (filename, 0, GDBM_READER, 0666, NULL)) == NULL) {
  232. #else
  233. # ifdef NDBM
  234.     if((thedb = dbm_open(filename, O_RDONLY, 0666)) == NULL) {
  235. # else
  236.     if(dbminit(filename) < 0) {
  237. # endif
  238. #endif
  239.         adios (filename, "Can't initialize data base");
  240.     }
  241. }
  242.  
  243.  
  244. static void open_table (tb, dir)
  245. Table *tb;
  246. char *dir;
  247. {
  248.     char filename[MAXPATHLENGTH];
  249.     char *mode;
  250.  
  251.     if (tb -> tb_fp != NULL)
  252.         return;
  253.  
  254.     (void) sprintf (filename, "%s/%s", dir, tb -> tb_file);
  255.  
  256.     if (verbose)
  257.         printf ("Opening %s\n", filename);
  258.     mode = (tb -> tb_flags & TB_FLAG_MAGIC) ? "a" : "w";
  259.     if ((tb -> tb_fp = fopen (filename, mode)) == NULL) {
  260.         if (errno == EMFILE) {
  261.             close_a_file ();
  262.                     
  263.         }
  264.         if ((tb -> tb_fp = fopen (filename, mode)) == NULL)
  265.             adios (filename, "Can't open file");
  266.     }
  267. }
  268.  
  269. static void close_a_file ()
  270. {
  271.  
  272.     static Table **tbstart;
  273.     Table **tb;
  274.  
  275.     if (tbstart == NULL)
  276.         tbstart = tb_all;
  277.  
  278.     tb = tbstart;
  279.  
  280.     for (;;) {
  281.         if ((*tb) -> tb_fp != NULL) {
  282.             if (fclose ((*tb) -> tb_fp) == EOF)
  283.                 adios ("failed", "Write");
  284.             (*tb) -> tb_fp = NULL;
  285.             (*tb) -> tb_flags |= TB_FLAG_MAGIC;
  286.             break;
  287.         }
  288.         tb ++;
  289.         if (*tb == NULL)
  290.             tb = tb_all;
  291.     }
  292.     tbstart = tb;
  293. }
  294.  
  295. close_tables ()
  296. {
  297.     Table **tb;
  298.  
  299.     for (tb = tb_all; *tb; tb++)
  300.         if ((*tb) -> tb_fp)
  301.             if (fclose ((*tb) -> tb_fp) == EOF)
  302.                 adios ("failed", "fclose");
  303. }
  304.  
  305. #ifndef    lint
  306. static void _advise ();
  307.  
  308. static void    adios (va_alist)
  309. va_dcl
  310. {
  311.     va_list ap;
  312.  
  313.     va_start (ap);
  314.  
  315.     _advise (ap);
  316.  
  317.     va_end (ap);
  318.  
  319.     _exit (1);
  320. }
  321. #else
  322. /* VARARGS */
  323.  
  324. static void    adios (what, fmt)
  325. char   *what,
  326.        *fmt;
  327. {
  328.     adios (what, fmt);
  329. }
  330. #endif
  331.  
  332.  
  333. #ifndef    lint
  334. static void    advise (va_alist)
  335. va_dcl
  336. {
  337.     va_list ap;
  338.  
  339.     va_start (ap);
  340.  
  341.     _advise (ap);
  342.  
  343.     va_end (ap);
  344. }
  345.  
  346.  
  347. static void  _advise (ap)
  348. va_list    ap;
  349. {
  350.     char    buffer[BUFSIZ];
  351.  
  352.     asprintf (buffer, ap);
  353.  
  354.     (void) fflush (stdout);
  355.  
  356.     fprintf (stderr, "%s: ", myname);
  357.     (void) fputs (buffer, stderr);
  358.     (void) fputc ('\n', stderr);
  359.  
  360.     (void) fflush (stderr);
  361. }
  362. #else
  363. /* VARARGS */
  364.  
  365. static void    advise (what, fmt)
  366. char   *what,
  367.        *fmt;
  368. {
  369.     advise (what, fmt);
  370. }
  371. #endif
  372.